home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / m2c / Check.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  17KB  |  528 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Automaton
  4. #include "Automaton.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Debug
  8. #include "Debug.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Errors
  12. #include "Errors.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Idents
  16. #include "Idents.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Strings
  28. #include "Strings.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_SysError
  32. #include "SysError.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Positions
  36. #include "Positions.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_TokenTab
  40. #include "TokenTab.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Check
  44. #include "Check.h"
  45. #endif
  46.  
  47. BOOLEAN Check_Verbose;
  48.  
  49. #define eState    70
  50. #define eReadRed    71
  51. #define eRedRed    72
  52. #define eReadRedRed    73
  53. #define eRepReadRed    74
  54. #define eRepRedRed    75
  55. #define eRepReadRedRed    76
  56. #define eARepReadRed    77
  57. #define eARepRedRed    78
  58. #define eARepReadRedRed    79
  59. static CHAR DevNull [] = "/dev/null";
  60. static CHAR DEBUG [] = "_Debug";
  61. static void RepairConflict ARGS((Automaton_tStateIndex state, Sets_tSet *ConflictSet));
  62. static void ERROR ARGS((CHAR a[], LONGCARD ));
  63.  
  64.  
  65. void Check_CheckForConflicts
  66. # ifdef __STDC__
  67. (BOOLEAN *ok)
  68. # else
  69. (ok)
  70. BOOLEAN *ok;
  71. # endif
  72. {
  73.   Sets_tSet SymbolSet, ConflictSet, TempSet;
  74.   Automaton_tStateIndex state, maxState;
  75.   Automaton_tItemIndex item;
  76.   BOOLEAN Error;
  77.   Strings_tString string;
  78.  
  79.   Error = FALSE;
  80.   Sets_MakeSet(&SymbolSet, (LONGCARD)TokenTab_MAXTerm);
  81.   Sets_MakeSet(&ConflictSet, (LONGCARD)TokenTab_MAXTerm);
  82.   Sets_MakeSet(&TempSet, (LONGCARD)TokenTab_MAXTerm);
  83.   if (Check_Verbose) {
  84.     Debug_dFile = IO_WriteOpen(DEBUG, 6L);
  85.     if (SysError_StatIsBad(Debug_dFile)) {
  86.       Strings_ArrayToString(DEBUG, 6L, &string);
  87.       SysError_SysErrorMessageI(Debug_dFile, (LONGCARD)Errors_eError, (LONGCARD)Errors_eString, ADR(string));
  88.       Debug_dFile = IO_WriteOpen(DevNull, 9L);
  89.       if (SysError_StatIsBad(Debug_dFile)) {
  90.         Strings_ArrayToString(DevNull, 9L, &string);
  91.         SysError_SysErrorMessageI(Debug_dFile, (LONGCARD)Errors_eFatal, (LONGCARD)Errors_eString, ADR(string));
  92.       }
  93.     }
  94.   }
  95.   maxState = Automaton_StateIndex;
  96.   {
  97.     Automaton_tStateIndex B_1 = 1, B_2 = maxState;
  98.  
  99.     if (B_1 <= B_2)
  100.       for (state = B_1;; state += 1) {
  101.         {
  102.           register Automaton_tState *W_1 = &Automaton_StateArrayPtr->A[state - 1];
  103.  
  104.           {
  105.             LONGCARD B_3 = W_1->Items, B_4 = W_1->Items + W_1->Size - 1;
  106.  
  107.             if (B_3 <= B_4)
  108.               for (item = B_3;; item += 1) {
  109.                 {
  110.                   register Automaton_tItem *W_2 = &Automaton_ItemArrayPtr->A[item - 1];
  111.  
  112.                   W_2->Number = state;
  113.                 }
  114.                 if (item >= B_4) break;
  115.               }
  116.           }
  117.         }
  118.         if (state >= B_2) break;
  119.       }
  120.   }
  121.   {
  122.     Automaton_tStateIndex B_5 = 1, B_6 = maxState;
  123.  
  124.     if (B_5 <= B_6)
  125.       for (state = B_5;; state += 1) {
  126.         {
  127.           register Automaton_tState *W_3 = &Automaton_StateArrayPtr->A[state - 1];
  128.  
  129.           Sets_AssignEmpty(&ConflictSet);
  130.           Sets_AssignEmpty(&SymbolSet);
  131.           {
  132.             LONGCARD B_7 = W_3->Items, B_8 = W_3->Items + W_3->Size - 1;
  133.  
  134.             if (B_7 <= B_8)
  135.               for (item = B_7;; item += 1) {
  136.                 {
  137.                   register Automaton_tItem *W_4 = &Automaton_ItemArrayPtr->A[item - 1];
  138.  
  139.                   switch (W_4->Rep) {
  140.                   case Automaton_TermRep:;
  141.                     if (Sets_IsElement((LONGCARD)W_4->Read, &SymbolSet)) {
  142.                       Sets_Include(&ConflictSet, (LONGCARD)W_4->Read);
  143.                     } else {
  144.                       Sets_Include(&SymbolSet, (LONGCARD)W_4->Read);
  145.                     }
  146.                     break;
  147.                   case Automaton_RedRep:;
  148.                     Sets_Assign(&TempSet, W_4->Set);
  149.                     Sets_Intersection(&TempSet, SymbolSet);
  150.                     Sets_Union(&ConflictSet, TempSet);
  151.                     Sets_Union(&SymbolSet, W_4->Set);
  152.                     break;
  153.                   default :
  154.                     break;
  155.                   }
  156.                 }
  157.                 if (item >= B_8) break;
  158.               }
  159.           }
  160.           if (!Sets_IsEmpty(ConflictSet)) {
  161.             RepairConflict(state, &ConflictSet);
  162.             if (!Sets_IsEmpty(ConflictSet)) {
  163.               Error = TRUE;
  164.             }
  165.           }
  166.         }
  167.         if (state >= B_6) break;
  168.       }
  169.   }
  170.   Sets_ReleaseSet(&TempSet);
  171.   Sets_ReleaseSet(&ConflictSet);
  172.   Sets_ReleaseSet(&SymbolSet);
  173.   *ok = !Error;
  174.   if (Check_Verbose) {
  175.     IO_WriteClose(Debug_dFile);
  176.   }
  177. }
  178.  
  179. static void RepairConflict
  180. # ifdef __STDC__
  181. (Automaton_tStateIndex state, Sets_tSet *ConflictSet)
  182. # else
  183. (state, ConflictSet)
  184. Automaton_tStateIndex state;
  185. Sets_tSet *ConflictSet;
  186. # endif
  187. {
  188.   Sets_tSet todo;
  189.   TokenTab_Terminal LookAhead;
  190.   Sets_tSet ReadRedSet, RedRedSet, ReadRedRedSet, RepReadRedSet, RepRedRedSet, RepReadRedRedSet, ARepReadRedSet, ARepRedRedSet, ARepReadRedRedSet;
  191.   TokenTab_Prio Priority, ReducePri, ShiftPri;
  192.   Automaton_tAss Associativity, ReduceAss, ShiftAss;
  193.   Automaton_tIndex MinProdNo;
  194.   BOOLEAN OnlyOpers;
  195.   CARDINAL ReduceCount, ShiftCount, ReduceRest, ShiftRest;
  196.   Automaton_tItemIndex item;
  197.   Automaton_tProduction prod;
  198.   BOOLEAN ConflictFree;
  199.  
  200.   Sets_MakeSet(&ReadRedSet, (LONGCARD)TokenTab_MAXTerm);
  201.   Sets_MakeSet(&RedRedSet, (LONGCARD)TokenTab_MAXTerm);
  202.   Sets_MakeSet(&ReadRedRedSet, (LONGCARD)TokenTab_MAXTerm);
  203.   Sets_MakeSet(&RepReadRedSet, (LONGCARD)TokenTab_MAXTerm);
  204.   Sets_MakeSet(&RepRedRedSet, (LONGCARD)TokenTab_MAXTerm);
  205.   Sets_MakeSet(&RepReadRedRedSet, (LONGCARD)TokenTab_MAXTerm);
  206.   Sets_MakeSet(&ARepReadRedSet, (LONGCARD)TokenTab_MAXTerm);
  207.   Sets_MakeSet(&ARepRedRedSet, (LONGCARD)TokenTab_MAXTerm);
  208.   Sets_MakeSet(&ARepReadRedRedSet, (LONGCARD)TokenTab_MAXTerm);
  209.   if (Check_Verbose) {
  210.     Debug_DebugHead(state);
  211.     Debug_DebugState(state, ConflictSet);
  212.   }
  213.   Sets_MakeSet(&todo, (LONGCARD)TokenTab_MAXTerm);
  214.   Sets_Assign(&todo, *ConflictSet);
  215.   {
  216.     register Automaton_tState *W_5 = &Automaton_StateArrayPtr->A[state - 1];
  217.  
  218.     while (!Sets_IsEmpty(todo)) {
  219.       LookAhead = Sets_Extract(&todo);
  220.       OnlyOpers = TRUE;
  221.       ReduceCount = 0;
  222.       ShiftCount = 0;
  223.       ReduceRest = 0;
  224.       ShiftRest = 0;
  225.       ReducePri = 0;
  226.       ReduceAss = Automaton_none;
  227.       ShiftPri = 0;
  228.       ShiftAss = Automaton_none;
  229.       MinProdNo = 10000;
  230.       {
  231.         LONGCARD B_9 = W_5->Items, B_10 = W_5->Items + W_5->Size - 1;
  232.  
  233.         if (B_9 <= B_10)
  234.           for (item = B_9;; item += 1) {
  235.             {
  236.               register Automaton_tItem *W_6 = &Automaton_ItemArrayPtr->A[item - 1];
  237.  
  238.               if (W_6->Rep == Automaton_RedRep && Sets_IsElement((LONGCARD)LookAhead, &W_6->Set)) {
  239.                 INC(ReduceCount);
  240.                 prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_6->Prod]);
  241.                 if (prod->Pri == 0) {
  242.                   OnlyOpers = FALSE;
  243.                 } else if (prod->Pri > ReducePri) {
  244.                   ReducePri = prod->Pri;
  245.                   ReduceAss = prod->Ass;
  246.                 }
  247.                 if (prod->ProdNo < MinProdNo) {
  248.                   MinProdNo = prod->ProdNo;
  249.                 }
  250.               } else if (W_6->Rep == Automaton_TermRep && W_6->Read == LookAhead) {
  251.                 INC(ShiftCount);
  252.                 if (Automaton_OperArray.A[LookAhead].Pri == 0) {
  253.                   OnlyOpers = FALSE;
  254.                 } else {
  255.                   ShiftPri = Automaton_OperArray.A[LookAhead].Pri;
  256.                   ShiftAss = Automaton_OperArray.A[LookAhead].Ass;
  257.                 }
  258.               }
  259.             }
  260.             if (item >= B_10) break;
  261.           }
  262.       }
  263.       if (OnlyOpers) {
  264.         if (ReducePri > ShiftPri) {
  265.           Priority = ReducePri;
  266.           Associativity = ReduceAss;
  267.         } else {
  268.           Priority = ShiftPri;
  269.           Associativity = ShiftAss;
  270.         }
  271.         {
  272.           LONGCARD B_11 = W_5->Items, B_12 = W_5->Items + W_5->Size - 1;
  273.  
  274.           if (B_11 <= B_12)
  275.             for (item = B_11;; item += 1) {
  276.               {
  277.                 register Automaton_tItem *W_7 = &Automaton_ItemArrayPtr->A[item - 1];
  278.  
  279.                 if (W_7->Rep == Automaton_RedRep && Sets_IsElement((LONGCARD)LookAhead, &W_7->Set)) {
  280.                   prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_7->Prod]);
  281.                   if (prod->Pri < Priority) {
  282.                     if (Check_Verbose) {
  283.                       Debug_InformLowPri(item, LookAhead);
  284.                     }
  285.                     Sets_Exclude(&W_7->Set, (LONGCARD)LookAhead);
  286.                     if (Sets_IsEmpty(W_7->Set)) {
  287.                       W_7->Rep = Automaton_NoRep;
  288.                     }
  289.                   } else if (prod->Pri == Priority && (Associativity == Automaton_right || Associativity == Automaton_nonassoc) && ShiftPri == Priority) {
  290.                     if (Check_Verbose) {
  291.                       Debug_InformRightAss(item, LookAhead);
  292.                     }
  293.                     Sets_Exclude(&W_7->Set, (LONGCARD)LookAhead);
  294.                     if (Sets_IsEmpty(W_7->Set)) {
  295.                       W_7->Rep = Automaton_NoRep;
  296.                     }
  297.                   } else {
  298.                     if (Check_Verbose) {
  299.                       Debug_InformKept(item, LookAhead);
  300.                     }
  301.                     INC(ReduceRest);
  302.                   }
  303.                 } else if (W_7->Read == LookAhead) {
  304.                   if (ShiftPri < Priority) {
  305.                     if (Check_Verbose) {
  306.                       Debug_InformLowPri(item, LookAhead);
  307.                     }
  308.                     W_7->Rep = Automaton_NoRep;
  309.                   } else if (ShiftPri == Priority && (Associativity == Automaton_left || Associativity == Automaton_nonassoc) && ReducePri == Priority) {
  310.                     if (Check_Verbose) {
  311.                       Debug_InformLeftAss(item, LookAhead);
  312.                     }
  313.                     W_7->Rep = Automaton_NoRep;
  314.                   } else {
  315.                     if (Check_Verbose) {
  316.                       Debug_InformKept(item, LookAhead);
  317.                     }
  318.                     INC(ShiftRest);
  319.                   }
  320.                 }
  321.               }
  322.               if (item >= B_12) break;
  323.             }
  324.         }
  325.       } else {
  326.         if (ShiftCount > 0) {
  327.           {
  328.             LONGCARD B_13 = W_5->Items, B_14 = W_5->Items + W_5->Size - 1;
  329.  
  330.             if (B_13 <= B_14)
  331.               for (item = B_13;; item += 1) {
  332.                 {
  333.                   register Automaton_tItem *W_8 = &Automaton_ItemArrayPtr->A[item - 1];
  334.  
  335.                   if (W_8->Rep == Automaton_RedRep && Sets_IsElement((LONGCARD)LookAhead, &W_8->Set)) {
  336.                     if (Check_Verbose) {
  337.                       Debug_InformIgnored(item, LookAhead);
  338.                     }
  339.                     Sets_Exclude(&W_8->Set, (LONGCARD)LookAhead);
  340.                     if (Sets_IsEmpty(W_8->Set)) {
  341.                       W_8->Rep = Automaton_NoRep;
  342.                     }
  343.                   } else if (W_8->Read == LookAhead) {
  344.                     if (Check_Verbose) {
  345.                       Debug_InformKept(item, LookAhead);
  346.                     }
  347.                     INC(ShiftRest);
  348.                   }
  349.                 }
  350.                 if (item >= B_14) break;
  351.               }
  352.           }
  353.         } else {
  354.           {
  355.             LONGCARD B_15 = W_5->Items, B_16 = W_5->Items + W_5->Size - 1;
  356.  
  357.             if (B_15 <= B_16)
  358.               for (item = B_15;; item += 1) {
  359.                 {
  360.                   register Automaton_tItem *W_9 = &Automaton_ItemArrayPtr->A[item - 1];
  361.  
  362.                   if (W_9->Rep == Automaton_RedRep && Sets_IsElement((LONGCARD)LookAhead, &W_9->Set)) {
  363.                     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_9->Prod]);
  364.                     if (prod->ProdNo == MinProdNo) {
  365.                       if (Check_Verbose) {
  366.                         Debug_InformKept(item, LookAhead);
  367.                       }
  368.                       INC(ReduceRest);
  369.                     } else {
  370.                       if (Check_Verbose) {
  371.                         Debug_InformIgnored(item, LookAhead);
  372.                       }
  373.                       Sets_Exclude(&W_9->Set, (LONGCARD)LookAhead);
  374.                       if (Sets_IsEmpty(W_9->Set)) {
  375.                         W_9->Rep = Automaton_NoRep;
  376.                       }
  377.                     }
  378.                   }
  379.                 }
  380.                 if (item >= B_16) break;
  381.               }
  382.           }
  383.         }
  384.       }
  385.       ConflictFree = FALSE;
  386.       if (ReduceRest > 1) {
  387.         if (ShiftRest > 0) {
  388.           if (Check_Verbose) {
  389.             Debug_InformConflict(Debug_ShRedRed);
  390.           }
  391.           Sets_Include(&ReadRedRedSet, (LONGCARD)LookAhead);
  392.         } else {
  393.           if (Check_Verbose) {
  394.             Debug_InformConflict(Debug_RedRed);
  395.           }
  396.           Sets_Include(&RedRedSet, (LONGCARD)LookAhead);
  397.         }
  398.       } else if (ReduceRest == 1) {
  399.         if (ShiftRest > 0) {
  400.           if (Check_Verbose) {
  401.             Debug_InformConflict(Debug_ShRed);
  402.           }
  403.           Sets_Include(&ReadRedSet, (LONGCARD)LookAhead);
  404.         } else {
  405.           ConflictFree = TRUE;
  406.         }
  407.       } else {
  408.         ConflictFree = TRUE;
  409.       }
  410.       if (Check_Verbose) {
  411.         Debug_NewLine();
  412.       }
  413.       if (ConflictFree) {
  414.         Sets_Exclude(ConflictSet, (LONGCARD)LookAhead);
  415.         if (ReduceCount > 1) {
  416.           if (ShiftCount > 0) {
  417.             if (OnlyOpers) {
  418.               Sets_Include(&RepReadRedRedSet, (LONGCARD)LookAhead);
  419.             } else {
  420.               Sets_Include(&ARepReadRedRedSet, (LONGCARD)LookAhead);
  421.             }
  422.           } else {
  423.             if (OnlyOpers) {
  424.               Sets_Include(&RepRedRedSet, (LONGCARD)LookAhead);
  425.             } else {
  426.               Sets_Include(&ARepRedRedSet, (LONGCARD)LookAhead);
  427.             }
  428.           }
  429.         } else if (ReduceCount == 1) {
  430.           if (ShiftCount > 0) {
  431.             if (OnlyOpers) {
  432.               Sets_Include(&RepReadRedSet, (LONGCARD)LookAhead);
  433.             } else {
  434.               Sets_Include(&ARepReadRedSet, (LONGCARD)LookAhead);
  435.             }
  436.           } else {
  437.             ERROR((STRING)"Check.RepairConflict: No Conflict (1)", 37L);
  438.           }
  439.         } else {
  440.           ERROR((STRING)"Check.RepairConflict: No Conflict (2)", 37L);
  441.         }
  442.       }
  443.     }
  444.   }
  445.   Errors_ErrorMessageI((LONGCARD)eState, (LONGCARD)Errors_eInformation, Positions_NoPosition, (LONGCARD)Errors_eShort, ADR(state));
  446.   if (!Sets_IsEmpty(ReadRedSet)) {
  447.     Errors_ErrorMessageI((LONGCARD)eReadRed, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(ReadRedSet));
  448.   }
  449.   if (!Sets_IsEmpty(RedRedSet)) {
  450.     Errors_ErrorMessageI((LONGCARD)eRedRed, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(RedRedSet));
  451.   }
  452.   if (!Sets_IsEmpty(ReadRedRedSet)) {
  453.     Errors_ErrorMessageI((LONGCARD)eReadRedRed, (LONGCARD)Errors_eError, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(ReadRedRedSet));
  454.   }
  455.   if (!Sets_IsEmpty(RepReadRedSet)) {
  456.     Errors_ErrorMessageI((LONGCARD)eRepReadRed, (LONGCARD)Errors_eInformation, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(RepReadRedSet));
  457.   }
  458.   if (!Sets_IsEmpty(RepRedRedSet)) {
  459.     Errors_ErrorMessageI((LONGCARD)eRepRedRed, (LONGCARD)Errors_eInformation, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(RepRedRedSet));
  460.   }
  461.   if (!Sets_IsEmpty(RepReadRedRedSet)) {
  462.     Errors_ErrorMessageI((LONGCARD)eRepReadRedRed, (LONGCARD)Errors_eInformation, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(RepReadRedRedSet));
  463.   }
  464.   if (!Sets_IsEmpty(ARepReadRedSet)) {
  465.     Errors_ErrorMessageI((LONGCARD)eARepReadRed, (LONGCARD)Errors_eWarning, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(ARepReadRedSet));
  466.   }
  467.   if (!Sets_IsEmpty(ARepRedRedSet)) {
  468.     Errors_ErrorMessageI((LONGCARD)eARepRedRed, (LONGCARD)Errors_eWarning, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(ARepRedRedSet));
  469.   }
  470.   if (!Sets_IsEmpty(ARepReadRedRedSet)) {
  471.     Errors_ErrorMessageI((LONGCARD)eARepReadRedRed, (LONGCARD)Errors_eWarning, Positions_NoPosition, (LONGCARD)Errors_eTermSet, ADR(ARepReadRedRedSet));
  472.   }
  473.   Sets_ReleaseSet(&ReadRedSet);
  474.   Sets_ReleaseSet(&RedRedSet);
  475.   Sets_ReleaseSet(&ReadRedRedSet);
  476.   Sets_ReleaseSet(&RepReadRedSet);
  477.   Sets_ReleaseSet(&RepRedRedSet);
  478.   Sets_ReleaseSet(&RepReadRedRedSet);
  479.   Sets_ReleaseSet(&ARepReadRedSet);
  480.   Sets_ReleaseSet(&ARepRedRedSet);
  481.   Sets_ReleaseSet(&ARepReadRedRedSet);
  482.   Sets_ReleaseSet(&todo);
  483.   if (Check_Verbose) {
  484.     Debug_DebugEnd();
  485.   }
  486. }
  487.  
  488. static void ERROR
  489. # ifdef __STDC__
  490. (CHAR a[], LONGCARD O_1)
  491. # else
  492. (a, O_1)
  493. CHAR a[];
  494. LONGCARD O_1;
  495. # endif
  496. {
  497.   Strings_tString s;
  498.   OPEN_ARRAY_LOCALS
  499.  
  500.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  501.   COPY_OPEN_ARRAY(a, O_1, CHAR)
  502.   Strings_ArrayToString(a, O_1, &s);
  503.   Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(s));
  504.   FREE_OPEN_ARRAYS
  505. }
  506.  
  507. void BEGIN_Check()
  508. {
  509.   static BOOLEAN has_been_called = FALSE;
  510.  
  511.   if (!has_been_called) {
  512.     has_been_called = TRUE;
  513.  
  514.     BEGIN_Automaton();
  515.     BEGIN_Debug();
  516.     BEGIN_Errors();
  517.     BEGIN_Idents();
  518.     BEGIN_IO();
  519.     BEGIN_Sets();
  520.     BEGIN_Strings();
  521.     BEGIN_SysError();
  522.     BEGIN_Positions();
  523.     BEGIN_TokenTab();
  524.  
  525.     Check_Verbose = FALSE;
  526.   }
  527. }
  528.